home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Resources / Online / Term / Extras / Source / term-source.lha / EndOfLineTranslate.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  5KB  |  416 lines
  1. /*
  2. **    EndOfLineTranslate.c
  3. **
  4. **    End-of-line character translation routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **:    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. STATIC STRPTR    CR_Translation,
  17.                 LF_Translation;
  18. STATIC WORD        CR_Trans_Len,
  19.                 LF_Trans_Len;
  20.  
  21. STATIC LONG
  22. Translate_CR_LF_1(STRPTR Data,LONG Size)
  23. {
  24.     STRPTR    String    = Data;
  25.     LONG    Count    = 0;
  26.     LONG    c;
  27.  
  28.     while(Size--)
  29.     {
  30.         switch(c = *Data++)
  31.         {
  32.             case '\r':
  33.  
  34.                 if(CR_Trans_Len)
  35.                 {
  36.                     *String++ = *CR_Translation;
  37.  
  38.                     Count++;
  39.                 }
  40.  
  41.                 break;
  42.  
  43.             case '\n':
  44.  
  45.                 if(LF_Trans_Len)
  46.                 {
  47.                     *String++ = *LF_Translation;
  48.  
  49.                     Count++;
  50.                 }
  51.  
  52.                 break;
  53.  
  54.             default:
  55.  
  56.                 *String++ = c;
  57.  
  58.                 Count++;
  59.  
  60.                 break;
  61.         }
  62.     }
  63.  
  64.     return(Count);
  65. }
  66.  
  67. STATIC LONG
  68. Translate_CR_LF_2x2(STRPTR Data,LONG Size)
  69. {
  70.     STRPTR    String    = Data;
  71.     LONG    Count    = 0;
  72.     LONG    c;
  73.  
  74.     /* ALWAYS */
  75.     {
  76.         BOOL GotIt = FALSE;
  77.         LONG i;
  78.  
  79.         for(i = 0 ; i < Size ; i++)
  80.         {
  81.             if(String[i] == '\r' || String[i] == '\n')
  82.             {
  83.                 GotIt = TRUE;
  84.  
  85.                 break;
  86.             }
  87.         }
  88.  
  89.         if(GotIt)
  90.         {
  91.             CopyMem(Data,StripBuffer,Size);
  92.  
  93.             String    = Data;
  94.             Data    = StripBuffer;
  95.         }
  96.         else
  97.             return(Size);
  98.     }
  99.  
  100.     while(Size--)
  101.     {
  102.         switch(c = *Data++)
  103.         {
  104.             case '\r':
  105.  
  106.                 if(CR_Trans_Len)
  107.                 {
  108.                     LONG i;
  109.  
  110.                     for(i = 0 ; i < CR_Trans_Len ; i++)
  111.                     {
  112.                         *String++ = CR_Translation[i];
  113.  
  114.                         Count++;
  115.                     }
  116.                 }
  117.  
  118.                 break;
  119.  
  120.             case '\n':
  121.  
  122.                 if(LF_Trans_Len)
  123.                 {
  124.                     LONG i;
  125.  
  126.                     for(i = 0 ; i < LF_Trans_Len ; i++)
  127.                     {
  128.                         *String++ = LF_Translation[i];
  129.  
  130.                         Count++;
  131.                     }
  132.                 }
  133.  
  134.                 break;
  135.  
  136.             default:
  137.  
  138.                 *String++ = c;
  139.  
  140.                 Count++;
  141.  
  142.                 break;
  143.         }
  144.     }
  145.  
  146.     return(Count);
  147. }
  148.  
  149. STATIC LONG
  150. Translate_CR_LF_2LF(STRPTR Data,LONG Size)
  151. {
  152.     STRPTR    String    = Data;
  153.     LONG    Count    = 0;
  154.     LONG    c;
  155.  
  156.     /* ALWAYS */
  157.     {
  158.         BOOL GotIt = FALSE;
  159.         LONG i;
  160.  
  161.         for(i = 0 ; i < Size ; i++)
  162.         {
  163.             if(String[i] == '\n')
  164.             {
  165.                 GotIt = TRUE;
  166.  
  167.                 break;
  168.             }
  169.         }
  170.  
  171.         if(GotIt)
  172.         {
  173.             CopyMem(Data,StripBuffer,Size);
  174.  
  175.             String    = Data;
  176.             Data    = StripBuffer;
  177.         }
  178.         else
  179.             return(Size);
  180.     }
  181.  
  182.     while(Size--)
  183.     {
  184.         switch(c = *Data++)
  185.         {
  186.             case '\r':
  187.  
  188.                 if(CR_Trans_Len)
  189.                 {
  190.                     LONG i;
  191.  
  192.                     for(i = 0 ; i < CR_Trans_Len ; i++)
  193.                     {
  194.                         *String++ = CR_Translation[i];
  195.  
  196.                         Count++;
  197.                     }
  198.                 }
  199.  
  200.                 break;
  201.  
  202.             case '\n':
  203.  
  204.                 if(LF_Trans_Len)
  205.                 {
  206.                     LONG i;
  207.  
  208.                     for(i = 0 ; i < LF_Trans_Len ; i++)
  209.                     {
  210.                         *String++ = LF_Translation[i];
  211.  
  212.                         Count++;
  213.                     }
  214.                 }
  215.  
  216.                 break;
  217.  
  218.             default:
  219.  
  220.                 *String++ = c;
  221.  
  222.                 Count++;
  223.  
  224.                 break;
  225.         }
  226.     }
  227.  
  228.     return(Count);
  229. }
  230.  
  231. STATIC LONG
  232. Translate_CR_LF_2CR(STRPTR Data,LONG Size)
  233. {
  234.     STRPTR    String    = Data;
  235.     LONG    Count    = 0;
  236.     LONG    c;
  237.  
  238.     /* ALWAYS */
  239.     {
  240.         BOOL GotIt = FALSE;
  241.         LONG i;
  242.  
  243.         for(i = 0 ; i < Size ; i++)
  244.         {
  245.             if(String[i] == '\r')
  246.             {
  247.                 GotIt = TRUE;
  248.  
  249.                 break;
  250.             }
  251.         }
  252.  
  253.         if(GotIt)
  254.         {
  255.             CopyMem(Data,StripBuffer,Size);
  256.  
  257.             String    = Data;
  258.             Data    = StripBuffer;
  259.         }
  260.         else
  261.             return(Size);
  262.     }
  263.  
  264.     while(Size--)
  265.     {
  266.         switch(c = *Data++)
  267.         {
  268.             case '\r':
  269.  
  270.                 if(CR_Trans_Len)
  271.                 {
  272.                     LONG i;
  273.  
  274.                     for(i = 0 ; i < CR_Trans_Len ; i++)
  275.                     {
  276.                         *String++ = CR_Translation[i];
  277.  
  278.                         Count++;
  279.                     }
  280.                 }
  281.  
  282.                 break;
  283.  
  284.             case '\n':
  285.  
  286.                 if(LF_Trans_Len)
  287.                 {
  288.                     LONG i;
  289.  
  290.                     for(i = 0 ; i < LF_Trans_Len ; i++)
  291.                     {
  292.                         *String++ = LF_Translation[i];
  293.  
  294.                         Count++;
  295.                     }
  296.                 }
  297.  
  298.                 break;
  299.  
  300.             default:
  301.  
  302.                 *String++ = c;
  303.  
  304.                 Count++;
  305.  
  306.                 break;
  307.         }
  308.     }
  309.  
  310.     return(Count);
  311. }
  312.  
  313. VOID
  314. Update_CR_LF_Translation()
  315. {
  316.     Forbid();
  317.  
  318.     if(Config->TerminalConfig->ReceiveCR == EOL_CRLF || Config->TerminalConfig->ReceiveCR == EOL_LFCR || Config->TerminalConfig->ReceiveLF == EOL_LFCR || Config->TerminalConfig->ReceiveLF == EOL_CRLF)
  319.         SerialBufferSize = Config->SerialConfig->SerialBufferSize / 2;
  320.     else
  321.         SerialBufferSize = Config->SerialConfig->SerialBufferSize;
  322.  
  323.     switch(Config->TerminalConfig->ReceiveCR)
  324.     {
  325.         case EOL_IGNORE:
  326.  
  327.             CR_Trans_Len = 0;
  328.             break;
  329.  
  330.         case EOL_CR:
  331.  
  332.             CR_Trans_Len    = 1;
  333.             CR_Translation    = "\r";
  334.             break;
  335.  
  336.         case EOL_LF:
  337.  
  338.             CR_Trans_Len    = 1;
  339.             CR_Translation    = "\n";
  340.             break;
  341.  
  342.         case EOL_CRLF:
  343.  
  344.             CR_Trans_Len    = 2;
  345.             CR_Translation    = "\r\n";
  346.             break;
  347.  
  348.         case EOL_LFCR:
  349.  
  350.             CR_Trans_Len    = 2;
  351.             CR_Translation    = "\n\r";
  352.             break;
  353.     }
  354.  
  355.     switch(Config->TerminalConfig->ReceiveLF)
  356.     {
  357.         case EOL_IGNORE:
  358.  
  359.             LF_Trans_Len = 0;
  360.             break;
  361.  
  362.         case EOL_LF:
  363.  
  364.             LF_Trans_Len    = 1;
  365.             LF_Translation    = "\n";
  366.             break;
  367.  
  368.         case EOL_CR:
  369.  
  370.             LF_Trans_Len    = 1;
  371.             LF_Translation    = "\r";
  372.             break;
  373.  
  374.         case EOL_LFCR:
  375.  
  376.             LF_Trans_Len    = 2;
  377.             LF_Translation    = "\n\r";
  378.             break;
  379.  
  380.         case EOL_CRLF:
  381.  
  382.             LF_Trans_Len    = 2;
  383.             LF_Translation    = "\r\n";
  384.             break;
  385.     }
  386.  
  387.     if(Config->TerminalConfig->ReceiveCR == EOL_CR && Config->TerminalConfig->ReceiveLF == EOL_LF)
  388.         Translate_CR_LF = NULL;
  389.     else
  390.     {
  391.         if(LF_Trans_Len <= 1 && CR_Trans_Len <= 1)
  392.             Translate_CR_LF = Translate_CR_LF_1;
  393.         else
  394.         {
  395.             if(LF_Trans_Len == 2 && CR_Trans_Len == 2)
  396.                 Translate_CR_LF = Translate_CR_LF_2x2;
  397.             else
  398.             {
  399.                 if(LF_Trans_Len == 2)
  400.                     Translate_CR_LF = Translate_CR_LF_2LF;
  401.                 else
  402.                 {
  403.                     if(CR_Trans_Len == 2)
  404.                         Translate_CR_LF = Translate_CR_LF_2CR;
  405.                     else
  406.                         Translate_CR_LF = Translate_CR_LF_1;
  407.                 }
  408.             }
  409.         }
  410.     }
  411.  
  412.     ConTransferUpdate();
  413.  
  414.     Permit();
  415. }
  416.